package com.grape.result;

import com.grape.enums.ResultEnums;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.ToString;

/**
 * @author  putao
 * @email   2628279194@qq.com
 */
@Data
@ToString
public class R<T> {

    /** 是否成功 */
    @ApiModelProperty("是否成功")
    private boolean success;

    /** 状态码 */
    @ApiModelProperty("状态码")
    private int code;

    /** 消息 */
    @ApiModelProperty("消息")
    private String message;

    /** 数据 */
    @ApiModelProperty("数据")
    private T data;

    /** 其他 */
    @ApiModelProperty("其他")
    private Object other;

    public R(int code, String message){
        this.code = code;
        this.message = message;
    }

    public R(int code, String message, T data) {
        this.code = code;
        this.message = message;
        this.data = data;
    }

    public R(ResultEnums resultEnums) {
        this.code = resultEnums.getCode();
        this.message = resultEnums.getMessage();
        this.success = resultEnums.getSuccess();
    }

    public R(ResultEnums resultEnums, T data, Object other) {
        this.code = resultEnums.getCode();
        this.message = resultEnums.getMessage();
        this.success = resultEnums.getSuccess();
        this.data = data;
        this.other = other;
    }

    public R(ResultEnums resultEnums, T data, Object other, String message) {
        this.code = resultEnums.getCode();
        this.message = resultEnums.getMessage() + message;
        this.success = resultEnums.getSuccess();
        this.data = data;
        this.other = other;
    }

    public R(String message, ResultEnums resultEnums, T data, Object other) {
        this.code = resultEnums.getCode();
        this.message = message;
        this.success = resultEnums.getSuccess();
        this.data = data;
        this.other = other;
    }

    public R(boolean success, int code, String message, T data, Object other) {
        this.success = success;
        this.code = code;
        this.message = message;
        this.data = data;
        this.other = other;
    }

    public R() {
    }


    /**
     * 新增
     */
    public static <S> R<S> insertSuccess(S data, Object other) {
        return new R<>(ResultEnums.INSERT_SUCCESS, data, other);
    }

    /**
     * 修改
     */
    public static <S> R<S> updateSuccess(S data, Object other) {
        return new R<>(ResultEnums.UPDATE_SUCCESS, data, other);
    }
    public static <S> R<S> updateNotFound(S data, Object other) {
        return new R<>(ResultEnums.UPDATE_NOT_FOUND, data, other);
    }

    /**
     * 删除
     */
    public static <S> R<S> deleteSuccess(S data, Object other) {
        return new R<>(ResultEnums.DELETE_SUCCESS, data, other);
    }
    public static <S> R<S> deleteNotFound(S data, Object other) {
        return new R<>(ResultEnums.DELETE_NOT_FOUND, data, other);
    }

    /**
     * 删除状态错误
     * @param data  结果返回值
     * @param other 结果其他返回值
     * @return      通用接口结果
     * @param <S>   结果返回值类型
     */
    public static <S> R<S> deleteErrorByStatus(S data, Object other) {
        return new R<>(ResultEnums.DELETE_STATUS_ERROR, data, other);
    }

    /**
     * 查询
     * @param data  结果返回值
     * @param other 结果其他返回值
     * @return      通用接口结果
     * @param <T>   结果返回值类型
     */
    public static <T> R<T> selectSuccess(T data, Object other) {
        return new R<>(ResultEnums.SELECT_SUCCESS, data, other);
    }
    public static <T> R<T> selectNotFound(T data, Object other) {
        return new R<>(ResultEnums.SELECT_NOT_FOUND, data, other);
    }

    /**
     * 参数不满足
     * @param data  结果返回值
     * @param other 结果其他返回值
     * @return      通用接口结果
     */
    public static <S> R<S> argumentError(S data, Object other) {
        return new R<>(ResultEnums.VERIFY_PARAMETER_ERROR, data, other);
    }

    /**
     * 参数不满足
     * @param message   消息
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  argumentError(String message, S data, Object other) {
        return new R<>(message, ResultEnums.VERIFY_PARAMETER_ERROR, data, other);
    }

    /**
     * 操作成功
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  operationSuccess(S data, Object other) {
        return new R<>(ResultEnums.OPERATION_SUCCESS, data, other);
    }

    /**
     * 操作失败
     * @param message   消息
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  operationError(String message, S data, Object other) {
        return new R<>(message, ResultEnums.OPERATION_ERROR, data, other);
    }

    /**
     * 个人信息为空
     * @param message   消息
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  userInfoNotExistError(String message, S data, Object other) {
        return new R<>(message, ResultEnums.USERINFO_NOT_EXIST_ERROR, data, other);
    }

    /**
     * 个人信息为空
     * @param message   消息
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  parameterVerificationFailed(String message, S data, Object other) {
        return new R<>(message, ResultEnums.PARAMETER_VERIFICATION_FAILED, data, other);
    }

    /**
     * 操作失败
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  systemError(S data, Object other) {
        return new R<>(ResultEnums.SYSTEM_ERROR, data, other);
    }


    /**
     * 操作失败
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  authenticationError(S data, Object other) {
        return new R<>(ResultEnums.AUTHENTICATION_ERROR, data, other);
    }

    /**
     * 操作失败
     * @param message   消息
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  authenticationError(String message, S data, Object other) {
        return new R<>(ResultEnums.AUTHENTICATION_FAIL, data, other, message);
    }

    /**
     * 操作失败
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  invalidToken(S data, Object other) {
        return new R<>(ResultEnums.INVALID_TOKEN, data, other);
    }

    /**
     * token过期
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  overdueToken(S data, Object other) {
        return new R<>(ResultEnums.OVERDUE_TOKEN, data, other);
    }

    /**
     * token过期
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  overdueTokenV2(S data, Object other) {
        return new R<>(ResultEnums.OVERDUE_TOKEN_V2, data, other);
    }

    /**
     * token过期
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  noPermission(S data, Object other) {
        return new R<>(ResultEnums.AUTHENTICATION_NO_PERMISSION, data, other);
    }

    /**
     * token过期
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  parseTokenError(S data, Object other) {
        return new R<>(ResultEnums.PARSE_TOKEN_ERROR, data, other);
    }

    /**
     * 成功结果
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  resultSuccess(S data, Object other) {
        return new R<>(ResultEnums.OPERATION_SUCCESS, data, other);
    }

    /**
     * 退出登录成功
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口结果
     */
    public static <S> R<S>  logoutSuccess(S data, Object other) {
        return new R<>(ResultEnums.LOGOUT_SUCCESS, data, other);
    }

    /**
     * 重复提交
     * @param data      结果返回值
     * @param other     结果其他返回值
     * @return          通用接口
     */
    public static <S> R<S>  repeatSubmit(S data, Object other) {
        return new R<>(ResultEnums.REPEAT_SUBMIT, data, other);
    }

    /**
     * 服务正在加载中
     */
    public static <S> R<S> serviceLoading(S data, Object other) {
        return new R<>(ResultEnums.SERVICE_LOADING, data, other);
    }

    /**
     * 兜底数据
     */
    public  static <S> R<S>  callback(S data, Object other) {
        return new R<>(ResultEnums.CALL_BACK_DATA, data, other);
    }

}
